home *** CD-ROM | disk | FTP | other *** search
/ A.C.E. 3 / ACE CD 3.iso / files / utils / cando22.dms / in.adf / HelpFiles / Variables, Advanced  < prev    next >
Encoding:
Text File  |  1992-08-30  |  10.7 KB  |  497 lines
  1. F- Alias                |alias|
  2. F- BumpRevision            |bumprevision|
  3. F- Case                    |case|
  4. F- CharsToHex            |charstohex|
  5. C- DeleteArrayEntry        |deletearrayentry|
  6. F- Evaluate                |evaluate|
  7. F- EvaluateExpression    |evaluateexpression|
  8. F- FirstArrayIndex        |firstarrayindex|
  9. F- FormatValue            |formatvalue|
  10. V- GetDBObjects            |getdbobjects|
  11. C- Global                |global|
  12. F- HexToChars            |hextochars|
  13. F- HexToInteger            |hextointeger|
  14. V- Infinity                |infinity|
  15. F- IntegerToHex            |integertohex|
  16. F- IfThen                |ifthen|
  17. F- Input                |input|
  18. C- InsertArrayEntry        |insertarrayentry|
  19. C- InsertRecordNames    |insertrecordnames|
  20. F- IsAlias                |isalias|
  21. F- LastArrayIndex        |lastarrayindex|
  22. F- Limit                |limit|
  23. F- LoadVariable            |loadvariable|
  24. C- Local                |local|
  25. F- Match                |match|
  26. F- NextArrayIndex        |nextarrayindex|
  27. V- NotANumber            |notanumber|
  28. F- NumberOfArrayEntries    |numberofarrayentries|
  29. F- PreviousArrayIndex    |previousarrayindex|
  30. C- SaveVariable            |savevariable|
  31. F- SearchArray            |searcharray|
  32. C- SetDBObjects            |setdbobjects|
  33. C- SetSearchArrayFlags    |setsearcharrayflags|
  34. C- SortArray            |sortarray|
  35. C- Static                |static|
  36. F- ValidReal            |validreal|
  37. F- VarType                |vartype|
  38. F- VerifyExpression        |verifyexpression|
  39. [E]
  40.  
  41. |alias|
  42. WT <Variable>=Alias({String})
  43. PL Makes the resulting variable the same
  44. PL variable as the variable name given in the
  45. PL {String}.  See the manual for a full
  46. PL description of this function.
  47. PT SEE ALSO: 
  48. BS IsAlias
  49. PT .
  50. ED
  51.  
  52. |bumprevision|
  53. WT {String}=BumpRevision({String})
  54. PL Changes the revision of {String} in the
  55. PL same manner as the Workbench Duplicate
  56. PL function does with a filename.  See the
  57. PL manual for a full description of this
  58. PL function.
  59. ED
  60.  
  61. |case|
  62. WT {Result}=Case({Integer}, {Expression1} [,up to ten expressions] )
  63. PL Returns the expression corresponding to the
  64. PL {Integer}.  For example:
  65. PL  <- Let X = 2
  66. PL  <- Echo Case(X,"Gold","Silver","Bronze")
  67. PL  -> Silver
  68. PT SEE ALSO: 
  69. BS IfThen
  70. PT  and 
  71. BS Match
  72. PT .
  73. ED
  74.  
  75. |charstohex|
  76. WT {HexString}=CharsToHex({String})
  77. PL This converts a normal string into a hex-
  78. PL string.  The hexstring will have twice as
  79. PL many characters as the given string.
  80. PL  <- Echo CharsToHex("CanDo 1.6")
  81. PL  -> 43616E446F2056312E36
  82. PT SEE ALSO: 
  83. BS HexToChars
  84. PT  and 
  85. BS FileWriteChars
  86. PT .
  87. ED
  88.  
  89. |deletearrayentry|
  90. WT DeleteArrayEntry <ArrayVar>, {ArrayIndex}
  91. PL Deletes the array entry at the given index
  92. PL in the specified array variable.  All
  93. PL indices greater than the specified index
  94. PL will be renumbered starting at Index+1.
  95. PL
  96. PT SEE ALSO: 
  97. BS InsertArrayEntry
  98. PT  and 
  99. BS Dispose
  100. PT .
  101. ED
  102.  
  103. |evaluate|
  104. WT {Result}=Evaluate({Expression})
  105. PT SEE: 
  106. BS EvaluateExpression
  107. PT .
  108. ED
  109.  
  110. |evaluateexpression|
  111. WT {Result}=EvaluateExpression({Expression})
  112. PL If the string contains a valid expression,
  113. PL this function returns its result.  If
  114. PL the expression is not valid it will cause
  115. PT a run time error.  Use 
  116. BS VerifyExpression
  117. PL
  118. PT first to avoid such problems. 
  119. ED
  120.  
  121. |firstarrayindex|
  122. WT {ArrayIndex}=FirstArrayIndex(<ArrayVar>)
  123. PL Returns the integer value of the smallest
  124. PL index in the array specified by VarName.
  125. PL If the array does not have any entries,
  126. PL this function will return the value 0 and
  127. PT the system variable 
  128. BS SearchFound
  129. PL  will be set
  130. PT to 
  131. BS False
  132. PT .  SEE ALSO: 
  133. BS LastArrayIndex
  134. PT .
  135. ED
  136.  
  137. |formatvalue|
  138. WT {String}=FormatValue({Value}, {FormatString})
  139. PL This will format {Value} using the
  140. PL {FormatString}, which describes how you want
  141. PL the number to represented.  See the manual
  142. PL for a full description of this function.
  143. ED
  144.  
  145. |getdbobjects|
  146. WT {RecordVar}=GetDBObjects
  147. PL Returns a record variable containing a
  148. PL Record corresponding to the matching
  149. PL qualifying Objects in the Current Card.
  150. PL See the manual for a full description
  151. PL of this system variable.
  152. PT SEE ALSO: 
  153. BS SetDBObjects
  154. PT .
  155. ED
  156.  
  157. |global|
  158. WT Global <VarName>
  159. PL All variables are global by default, except
  160. PT those that are declared with the 
  161. BS Local
  162. PL  and
  163. BS Static
  164. PL  commands, but this command was made
  165. PL for consistency.
  166. ED
  167.  
  168. |hextochars|
  169. WT {String}=HexToChars({HexString})
  170. PT This converts the result of 
  171. BS CharsToHex
  172. PL
  173. PT function or the 
  174. BS FileReadChars
  175. PL  command into
  176. PL a normal character string.
  177. ED
  178.  
  179. |hextointeger|
  180. WT {Integer}=HexToInteger({HexString})
  181. PT This converts the result of 
  182. BS IntegerToHex
  183. PL
  184. PT function or the 
  185. BS FileReadChars
  186. PL  command into
  187. PL a normal integer.
  188. ED
  189.  
  190. |infinity|
  191. WT {Real}=Infinity
  192. PL Returns the IEEE double precision value for
  193. PL Infinity.  See the manual for a full
  194. PL description of this system variable.
  195. PL
  196. PT SEE ALSO: 
  197. BS NotANumber
  198. PT  and 
  199. BS ValidReal
  200. PT .
  201. ED
  202.  
  203. |ifthen|
  204. WT {Result}=IfThen({Logical}, {TrueExpression} [,{FalseExpression}])
  205. PL This returns the {TrueExpression} if the
  206. PT {Logical} is 
  207. BS True
  208. PL , otherwise it returns the
  209. PT {FalseExpression} or 
  210. BS Nothing
  211. PL  if the {False-
  212. PL Expression} is not given.
  213. PL
  214. PT SEE ALSO: 
  215. BS Match
  216. PT  and 
  217. BS Case
  218. PT .
  219. ED
  220.  
  221. |input|
  222. WT {String}=Input({Prompt})
  223. PL Similar to Input Function in BASIC.  It
  224. PL displays the "Prompt" in the CLI and waits
  225. PL for user to type information ending in the
  226. PL RETURN key being pressed.  This function
  227. PL returns the information typed by the user.
  228. PL You must have a CLI for this to work.
  229. ED
  230.  
  231. |insertarrayentry|
  232. WT InsertArrayEntry <ArrayVar>, {ArrayIndex}
  233. PL Makes room for a new array index in the
  234. PL specified array.  This cause all Array
  235. PL Indicies grater than the specified Index to
  236. PL be renumbered starting at Index+1.  This
  237. PL is useful for adding records to a database.
  238. PT SEE ALSO: 
  239. BS DeleteArrayEntry
  240. PT .
  241. ED
  242.  
  243. |insertrecordnames|
  244. WT InsertRecordNames <RecordVar>
  245. PL Types the record names for the specified
  246. PL RecordVar into the current document.  This
  247. PL can be used to find out any unknown Record
  248. PL Names within the variable specified.
  249. ED
  250.  
  251. |integertohex|
  252. WT {HexString}=IntegerToHex({Integer})
  253. PL This converts an integer into a hexstring.
  254. PL The resulting string will be two, four, six
  255. PL or eight characters long.
  256. PL  <- Echo IntegerToHex(1256)
  257. PL  -> 04E8
  258. PT SEE ALSO: 
  259. BS HexToInteger
  260. PT  and 
  261. BS CharsToHex
  262. PT .
  263. ED
  264.  
  265. |isalias|
  266. WT {Logical}=IsAlias(<VarName>)
  267. PT This returns 
  268. BS True
  269. PL  if the variable indicated
  270. PL by <VarName> is an aliased variable.
  271. PL
  272. PT SEE ALSO: 
  273. BS Alias
  274. PT .
  275. ED
  276.  
  277. |lastarrayindex|
  278. WT {ArrayIndex}=LastArrayIndex(<ArrayVar>)
  279. PL Returns the integer value of the largest
  280. PL index in the array specified by VarName.
  281. PL If the array does not have any entries,
  282. PL this function will return the value 0 and
  283. PT the system variable 
  284. BS SearchFound
  285. PL  will be set
  286. PT to 
  287. BS False
  288. PT .  SEE ALSO: 
  289. BS FirstArrayIndex
  290. PT .
  291. ED
  292.  
  293. |limit|
  294. WT {Integer}=Limit({MinLimit}, {MaxLimit}, {TestInteger})
  295. PL Returns the {TestInteger} if it is between
  296. PL {MinLimit} and {MaxLimit}.  If {TestInteger}
  297. PL is greater than both limits, it will return
  298. PL the larger of the limits.  If {TestInteger}
  299. PL is smaller than both limits, it will return
  300. PL the smaller of the limits.
  301. ED
  302.  
  303. |loadvariable|
  304. WT {Result}=LoadVariable({FilePath})
  305. PL Returns the contents of the variable which
  306. PL was saved in the given file.
  307. PL 
  308. PT SEE ALSO: 
  309. BS SaveVariable
  310. PT .
  311. ED
  312.  
  313. |local|
  314. WT Local <VarName>
  315. PL Declares a variable as available only to
  316. PL the currently running script.
  317. PL
  318. PT SEE ALSO: 
  319. BS Static
  320. PT  and 
  321. BS Global
  322. PT .
  323. ED
  324.  
  325. |match|
  326. WT {Integer}=Match({Integer or String}, {MatchingData1} [,up to ten matching datas])
  327. PL Returns an integer value indicating which
  328. PL {Integer or String} matches any of the
  329. PL {MatchingData}s, or 0 if none do.  See the
  330. PL manual for a full description of this
  331. PL function.
  332. PT SEE ALSO: 
  333. BS Case
  334. PT  and 
  335. BS IfThen
  336. PT .
  337. ED
  338.  
  339. |nextarrayindex|
  340. WT {ArrayIndex}=NextArrayIndex(<ArrayVar>, {ArrayIndex})
  341. PL Returns the next larger Index value greater
  342. PL than <Index> in the array specified by
  343. PL VarName.  If there is not one, this
  344. PL function will return the given Index and
  345. PT set the system variable 
  346. BS SearchFound
  347. PL  to
  348. BS False
  349. PT .  SEE ALSO: 
  350. BS PreviousArrayIndex
  351. PT .
  352. ED
  353.  
  354. |notanumber|
  355. WT {Real}=NotANumber
  356. PL Contains the value returned by some floating
  357. PL point operations which have undefined
  358. PL results.  See the manual for a full
  359. PL description of this system variable.
  360. PT SEE ALSO: 
  361. BS Infinity
  362. PT  and 
  363. BS ValidReal
  364. PT .
  365. ED
  366.  
  367. |numberofarrayentries|
  368. WT {Integer}=NumberOfArrayEntries(<ArrayVar>)
  369. PL Returns the number of entries in the
  370. PL specified array.
  371. ED
  372.  
  373. |previousarrayindex|
  374. WT {Integer}=PreviousArrayIndex(<ArrayVar>, {ArrayIndex})
  375. PL Returns the next smaller Index value
  376. PL smaller than <Index> in the array specified
  377. PL by VarName.  If there is not one, this
  378. PL function will return the given Index and
  379. PT set the system variable 
  380. BS SearchFound
  381. PL  to
  382. BS False
  383. PT .  SEE ALSO: 
  384. BS NextArrayIndex
  385. PT .
  386. ED
  387.  
  388. |savevariable|
  389. WT SaveVariable <VarName>, {FilePath}
  390. PL Saves the contents of Variable into the
  391. PL specified file.  If the variable is an
  392. PL array or record, the entire array or record
  393. PL will be saved.
  394. PL 
  395. PT SEE ALSO: 
  396. BS LoadVariable
  397. PT .
  398. ED
  399.  
  400. |searcharray|
  401. WT {ArrayIndex}=SearchArray(<ArrayVar>, {DataToSearchFor} [,{KeyString} [,{StartAtIndex}]])
  402. PL Searches the given array for the given
  403. PL value.  The {KeyString} specifies the record
  404. PL name or subarray index to search on.  The
  405. PL {StartAtIndex} may also be specified.
  406. PT SEE ALSO: 
  407. BS SetSearchArrayFlags
  408. PL  and 
  409. PT           
  410. BS SearchFound
  411. PT .
  412. ED
  413.  
  414. |setdbobjects|
  415. WT SetDBObjects <RecordVar>
  416. PL Sets the DataBase qualifying objects in the
  417. PL window to the corresponding record entries.
  418. PL 
  419. PT SEE ALSO: 
  420. BS GetDBObjects
  421. PT .
  422. ED
  423.  
  424. |setsearcharrayflags|
  425. WT SetSearchArrayFlags <flags>
  426. PL This adjusts the searching parameters used
  427. PT by the 
  428. BS SearchArray
  429. PL  function.  See the
  430. PL manual for a full description of this
  431. PL command.
  432. ED
  433.  
  434. |sortarray|
  435. WT SortArray <ArrayVar>, <flags> [,{KeyString}]
  436. PL Sorts the specified array variable.  See
  437. PL the manual for a full description of this
  438. PL command.
  439. ED
  440.  
  441. |static|
  442. WT Static <VarName>
  443. PT This is like 
  444. BS Local
  445. PL , except static variables
  446. PL survive beyond the current execution.  Which
  447. PL means that the next time thru this script
  448. PL the variable will still contain the old
  449. PL value.
  450. PT SEE ALSO: 
  451. BS Global
  452. PT .
  453. ED
  454.  
  455. |validreal|
  456. WT {Logical}=ValidReal({Real})
  457. PT Returns 
  458. BS True
  459. PL  if the value is a valid
  460. PL non-infinite real number and is not a
  461. PL NotANumber.  See the manual for a full
  462. PL description of this function.
  463. PT SEE ALSO: 
  464. BS NotANumber
  465. PT  and 
  466. BS Infinity
  467. PT .
  468. ED
  469.  
  470. |vartype|
  471. WT {String}=VarType(<VarName>)
  472. PL Returns a string indicating the value type
  473. PL for a specified <VarName>.  The can be:
  474. PL "String", "Integer", "Real", "Logical",
  475. PL "Nothing", "System", "Array" or "Record".
  476. PT NOTE: 
  477. BS Alias
  478. PL  variables can only be discovered
  479. PT with the 
  480. BS IsAlias
  481. PL  function.
  482. ED
  483.  
  484. |verifyexpression|
  485. WT {Logical}=VerifyExpression({Expression})
  486. PT Returns 
  487. BS True
  488. PL  if the string contains a
  489. PL valid expression, otherwise it returns
  490. BS False
  491. PL .  This command should be used
  492. PT before using the 
  493. BS EvaluateExpression
  494. PL  function
  495. PL to avoid run time errors.
  496. ED
  497.